
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package wumpus.agente;

import java.util.ArrayList;
import java.util.List;
import wumpus.ambiente.Ambiente;

/**
 *
 * @author aline
 */
public class Agente {

    public Agente() {
    }

    /**
     * metodo que fara o aventureiro andar, ou seja ele ira receber a posicao em que o aventureiro
     * se envontra e ira atualizar a posicao do aventureiro
     * @param novaPosicao
     * @return nova posicao do aventureiro
     */
    public String fazAgenteCaminhar(String novaPosicao) {
        Ambiente.getAmbiente()[pegaLinha(novaPosicao)][pegaColuna(novaPosicao)][0] = Ambiente.getAVENTUREIRO();
        return Ambiente.posicaoAtualDoAventureiro(pegaLinha(novaPosicao), pegaColuna(novaPosicao));
    }

    /**
     * metodo responsavel por ler a posicao decorrente e retornar apenas a linha dela
     * @param posicaoAventureiro
     * @return a linha decorrente
     */
    public static int pegaLinha(String posicaoAventureiro) {
        int linha = Integer.parseInt(posicaoAventureiro.substring(0, 1));
        return linha;
    }

    /**
     * metodo responsavel por ler a posicao decorrente e retornar apenas a coluna dela
     * @param posicaoAventureiro
     * @return a coluna decorrente
     */
    public static int pegaColuna(String posicaoAventureiro) {
        int coluna = Integer.parseInt(posicaoAventureiro.substring(2, 3));
        return coluna;
    }

    /**
     * metodo que tomara a decisao pelo agente
     * retornando a posicao que o aventureiro devera seguir
     * @param posicaoAventureiro
     * @return retorna percepcaoA decisao, uma posicao, tomada pelo agente
     */
    public String decidePraOndeAGVai(String posicaoAventureiro) {
        String decisaoTomada = "";
        String decisaoFinal = "";
        List<String> listaDeDecisoes = new ArrayList<String>();
        int linha = Integer.parseInt(posicaoAventureiro.substring(0, 1));
        int coluna = Integer.parseInt(posicaoAventureiro.substring(2, 3));
        for (int k = 1; k < Ambiente.getNUMERO_MAXIMO_TERCEIRA_DIMENSAO(); k++) {
            decisaoTomada = verificaPercepcaoTomaDecisao(linha, coluna, k);
            listaDeDecisoes.add(decisaoTomada);
        }
        decisaoFinal = tomaDecisaoFinal(listaDeDecisoes);
        return decisaoFinal;
    }

    /**
     * metodo que recebe uma lista de decisoes, e decide para onde o aventureiro deve ir
     * @param listaDeDecisoes
     * @return retorna a decisão sortiada
     */
    public String tomaDecisaoFinal(List<String> listaDeDecisoes) {
        String a = listaDeDecisoes.get(0);
        String b = listaDeDecisoes.get(1);
        String c = listaDeDecisoes.get(2);
        String d = listaDeDecisoes.get(3);
        String e = listaDeDecisoes.get(4);
        String f = listaDeDecisoes.get(5);
        return sorteiaDecisaoFinal(a, b, c, d, e, f);
    }

    /**
     * 
     * @return retorna um valor sorteado de zero a cinco
     */
    public int sorteiaPossivelPosicaoFinal() {
        int valor = (int) (Math.random() * 6);
        return valor;
    }

    /**
     * metodo que recebe as percepcoes do ambiente e realiza um sorteio,
     * ignorando as percepcoes null, para decidir para onde o aventureiro deve ir
     * @param percepcaoA
     * @param percepcaoB
     * @param percepcaoC
     * @param percepcaoD
     * @param percepcaoE
     * @param percepcaoF
     * @return retorna uma String contendo a posicao sorteada
     */
    public String sorteiaDecisaoFinal(String percepcaoA, String percepcaoB, String percepcaoC, String percepcaoD, String percepcaoE, String percepcaoF) {
        int valorSorteado = sorteiaPossivelPosicaoFinal();
        String recebeValorSorteado = "";
        boolean encontrouValorSorteado = false;
        do {
            if (valorSorteado == 0) {
                if (percepcaoA != null) {
                    recebeValorSorteado = percepcaoA;
                    encontrouValorSorteado = true;
                } else {
                    valorSorteado = sorteiaPossivelPosicaoFinal();
                }
            } else if (valorSorteado == 1) {
                if (percepcaoB != null) {
                    recebeValorSorteado = percepcaoB;
                    encontrouValorSorteado = true;
                } else {
                    valorSorteado = sorteiaPossivelPosicaoFinal();
                }
            } else if (valorSorteado == 2) {
                if (percepcaoC != null) {
                    recebeValorSorteado = percepcaoC;
                    encontrouValorSorteado = true;
                } else {
                    valorSorteado = sorteiaPossivelPosicaoFinal();
                }
            } else if (valorSorteado == 3) {
                if (percepcaoD != null) {
                    recebeValorSorteado = percepcaoD;
                    encontrouValorSorteado = true;
                } else {
                    valorSorteado = sorteiaPossivelPosicaoFinal();
                }
            } else if (valorSorteado == 4) {
                if (percepcaoE != null) {
                    recebeValorSorteado = percepcaoE;
                    encontrouValorSorteado = true;
                } else {
                    valorSorteado = sorteiaPossivelPosicaoFinal();
                }
            } else if (valorSorteado == 5) {
                if (percepcaoF != null) {
                    recebeValorSorteado = percepcaoF;
                    encontrouValorSorteado = true;
                } else {
                    valorSorteado = sorteiaPossivelPosicaoFinal();
                }
            }
        } while (!encontrouValorSorteado);
        return recebeValorSorteado;
    }

    /**
     * metodo que verifica as percepcoes, de uma dada posicao, do aventureiro
     * e verifica quais serao as possiveis posicoes, dependendo da percepcao,
     * que o aventureiro poderia ir
     * @param i
     * @param j
     * @param z
     * @return retorna a posicao que o aventureiro poderia ir dependendo da percepcao
     */
    public String verificaPercepcaoTomaDecisao(int i, int j, int z) {
        String posicao = null;
        String posicaoObjeto = Ambiente.getAmbiente()[i][j][z];
        if (posicaoObjeto != null) {
            if (posicaoObjeto.equals(Ambiente.getBRISA())) {
                posicao = calculaPossiveisPosicoes(i, j);
            } else if (posicaoObjeto.equals(Ambiente.getFEDOR())) {
                posicao = calculaPossiveisPosicoes(i, j);
            } else if (posicaoObjeto.equals(Ambiente.getPOSICAO_SEGURA())) {
                posicao = calculaPossiveisPosicoes(i, j);
            }
        }
        return posicao;
    }

    /**
     * dada a posicao do aventureiro, e calculada as possiveis posicoes que ele poderia ir
     * @param i
     * @param j
     * @return retorna a posicao que o aventureiro deve seguir, dependendo da percepcao da posicao
     */
    public String calculaPossiveisPosicoes(int i, int j) {
        String a = calculaPosicaoEmCima(i, j);
        String b = calculaPosicaoDireita(i, j);
        String c = calculaPosicaoEmBaixo(i, j);
        String d = calculaPosicaoEsquerda(i, j);
        return decidePraOndeIr(a, b, c, d);
    }

    /**
     * realiza-se um sorteio, de modo que decide-se para onde o aventureiro deve seguir
     * baseado na posicao que ele se encontra
     * @param a
     * @param b
     * @param c
     * @param d
     * @return
     */
    public String decidePraOndeIr(String a, String b, String c, String d) {
        int valorSorteado = sorteio();
        String recebeValorSorteado = "";
        boolean encontrouValorSorteado = false;
        do {
            if (valorSorteado == 0) {
                if (a != null) {
                    recebeValorSorteado = a;
                    encontrouValorSorteado = true;
                } else {
                    valorSorteado = sorteio();
                }
            } else if (valorSorteado == 1) {
                if (b != null) {
                    recebeValorSorteado = b;
                    encontrouValorSorteado = true;
                } else {
                    valorSorteado = sorteio();
                }
            } else if (valorSorteado == 2) {
                if (c != null) {
                    recebeValorSorteado = c;
                    encontrouValorSorteado = true;
                } else {
                    valorSorteado = sorteio();
                }
            } else if (valorSorteado == 3) {
                if (d != null) {
                    recebeValorSorteado = d;
                    encontrouValorSorteado = true;
                } else {
                    valorSorteado = sorteio();
                }
            }
        } while (!encontrouValorSorteado);
        return recebeValorSorteado;
    }

    public int sorteio() {
        int valor = (int) (Math.random() * 4);
        return valor;
    }

    public String calculaPosicaoEmCima(int i, int j) {
        String posicaoEmCima = null;
        if (i < Ambiente.getNUMERO_MAXIMO_DE_LINHAS() - 1) {
            posicaoEmCima = String.valueOf(i + 1 + "," + j);
        }
        return posicaoEmCima;
    }

    public String calculaPosicaoDireita(int i, int j) {
        String posicaoDireita = null;
        if (j < Ambiente.getNUMERO_MAXIMO_DE_COLUNAS() - 1) {
            posicaoDireita = i + "," + String.valueOf(j + 1);
        }
        return posicaoDireita;
    }

    public String calculaPosicaoEmBaixo(int i, int j) {
        String posicaoEmBaixo = null;
        if (i > 0) {
            posicaoEmBaixo = String.valueOf(i - 1 + "," + j);
        }
        return posicaoEmBaixo;
    }

    public String calculaPosicaoEsquerda(int i, int j) {
        String posicaoEsquerda = null;
        if (j > 0) {
            posicaoEsquerda = i + "," + String.valueOf(j - 1);
        }
        return posicaoEsquerda;
    }
}
